Computer technology consumers utilize various types of storage technologies to retain files that store financial records, documents, photos and other data. The storage systems may move, modify, add or delete data, on behalf of these consumers, as directed by various unprivileged mode software programs (e.g., commonly known as applications). To satisfy consumer demands with respect to latency and efficiency, these storage systems consume a considerable share of available computing resources, including storage space capacities, processing threads, operating system components and/or the like. This share of resources, in addition to reading/writing data, employs various access control mechanisms to synchronize data between threads and maintain consistency amongst variables (e.g., global variables).
A typical storage vendor supplies device-specific software programs that are configured to facilitate the above mentioned control mechanisms as well as perform block-level addressing. These programs run in privileged mode and are commonly known as device drivers. Each device-specific software program, when executed and combined with other privileged mode drivers, collectively function as storage architecture (e.g., a stack of kernel mode drivers and/or compatible storage hardware components). The unprivileged software programs mentioned above utilize this architecture to perform various data storage/retrieval tasks, such as reading/writing data. In the current state of the art, these tasks often result in reduced input/output bandwidth and increased response latency because of the reasons explained below.
Mainly due to overhead caused by some storage architecture components, it is becoming more difficult for current storage devices to handle the increasing loads of input/output requests. These storage architecture components may be unrelated to successfully completing certain data storage/retrieval tasks, but these components are executed anyway, which results in considerable processor overhead. High input/output loads are other example situations that cause a noticeable level of overhead. As another example, executing the data storage/retrieval tasks also can strain a processor already burdened with a considerable number of other tasks. The processor can be further burdened with context switches (e.g., changing program state) when the operating system handles file system operations asynchronously. Because of at least these reasons, the storage architecture described above is limited with respect to input/output efficiency.